python -m pip install numpy pandas
pip install numpy pandas
pip list

# Iterar sobre lista
frutas = ["manzana", "plátano", "naranja"]
for it_fruta in frutas:
    print(it_fruta)

# Iterar sobre rango
for it_range in range(5):  # 0, 1, 2, 3, 4
    print(f"Número: {it_range}")

# Iterar sobre string
for it_letra in "Python":
    print(it_letra)

# Iterar con índice
for it_indice, it_fruta in enumerate(frutas):
    print(f"{it_indice}: {it_fruta}")

# Iterar sobre múltiples secuencias simultáneamente
nombres = ["Ana", "Bob", "Carlos"]
edades = [25, 30, 35]
for it_nombre, it_edad in zip(nombres, edades):
    print(f"{nombre} tiene {edad} años")

# Crear lista de cuadrados
[x**2 for x in range(5)] # [0, 1, 4, 9, 16]

# Con condición
[x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]

# Comprensión de diccionario
{x: x**2 for x in range(4)} # {0: 0, 1: 1, 2: 4, 3: 9}

# Iterar sobre diccionarios
persona = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}

# Iterar sobre claves
for it_clave in persona:
    print(it_clave)

# Iterar sobre valores
for it_valor in persona.values():
    print(it_valor)

# Iterar sobre pares clave-valor
for it_clave, it_valor in persona.items():
    print(f"{it_clave}: {it_valor}")

# Contador simple
contador = 0
while contador < 5:
    print(f"Contador: {contador}")
    contador += 1

# Validación de entrada
mientras = True
while mientras:
    respuesta = input("¿Continuar? (s/n): ")
    if respuesta.lower() == 'n':
        mientras = False

for i in range(10):
    if i == 5:
        break  # Sale del loop
    print(i)  # Output: 0, 1, 2, 3, 4

for i in range(5):
    if i == 2:
        continue  # Salta i=2
    print(i)  # Output: 0, 1, 3, 4

for i in range(5):
    print(i)
else:
    print("Loop completado sin break")

# Opcion a:
def fibonacci(i):
    if i == 0: return 0
    if i == 1: return 1
    
    a, b = 0, 1
    
    for it in range(2, i + 1):
        a = b 
        b = a + b

    return b

# Opcion b:
def fibonacci(i):
    if i == 0: return 0
    if i == 1: return 1

    resultado = fibonacci(i - 1) + fibonacci(i - 2)

    return resultado

for it in range(0, 100):
    print(fibonacci(it))

# archivo: matematica.py
def sumar(a, b):
    return a + b

def restar(a, b):
    return a - b

PI = 3.14159

# Importar Módulo Completo
import matematica
resultado = matematica.sumar(5, 3)  # Output: 8


# Importar Funciones Específicas
from matematica import sumar, PI

resultado = sumar(10, 5)  # Output: 15
print(PI)                 # Output: 3.14159


# Importar con Alias
import matematica as mat
from mat import sumar as suma_numeros

resultado = suma_numeros(7, 2)


# Importar todo
import * from matematica

resultado = sumar(7, 2)

import math
print(math.sqrt(16))      # 4.0
print(math.pi)            # 3.14159...
print(math.factorial(5))  # 120

import random
print(random.randint(1, 10))      # Entero aleatorio
print(random.choice([1, 2, 3]))   # Elemento aleatorio
print(random.shuffle([1, 2, 3]))  # Mezcla lista

from datetime import datetime, timedelta
ahora = datetime.now()
print(ahora)
mañana = ahora + timedelta(days=1)

import os
print(os.getcwd())        # Directorio actual
os.mkdir("nueva_carpeta") # Crear carpeta

class Persona:
    """Clase que representa una persona"""
    
    def __init__(self, nombre, edad):
        """Constructor: inicializa atributos"""
        self.nombre = nombre
        self.edad = edad
    
    def saludar(self, apellido = ""):
        """Método: función dentro de la clase"""
        return f"Hola, soy {self.nombre} {apellido}"

# Crear objeto (instancia)
persona1 = Persona("Ana", 25)
print(persona1.saludar("Martinez")) 
# Output: Hola, soy Ana Martinez

class Animal:
    """Clase base (superclase)"""
    def __init__(self, nombre):
        self.nombre = nombre
    
    def hacer_sonido(self):
        return "Sonido genérico"

class Perro(Animal):
    """Clase derivada (subclase) hereda de Animal"""
    pass

# Uso
perro = Perro("Max")
print(perro.nombre)
# Output: Max (heredado)
print(perro.hacer_sonido())
# Output: Sonido genérico (heredado)

class Animal:
    """Clase base (superclase)"""
    def __init__(self, nombre):
        self.nombre = nombre
    
    def hacer_sonido(self):
        return "Sonido genérico"

class Perro(Animal):
    def hacer_sonido(self):
        return "¡Guau! ¡Guau!"

class Gato(Animal):
    def hacer_sonido(self):
        return "Miau miau"

# Uso
perro = Perro("Rex")
gato = Gato("Whiskers")
print(perro.hacer_sonido())
# Output: ¡Guau! ¡Guau!
print(gato.hacer_sonido())
# Output: Miau miau

class Animal:
    """Clase base (superclase)"""
    def __init__(self, nombre):
        self.nombre = nombre
    
    def hacer_sonido(self):
        return "Sonido genérico"

class Perro(Animal):
    def __init__(self, nombre, raza):
         # Llama al constructor de Animal
        Animal.__init__(nombre)
        # super().__init__(nombre)  # Llama constructor padre
        self.raza = raza

    def hacer_sonido(self):
        return "¡Guau! ¡Guau!"

class Gato(Animal):
    def hacer_sonido(self):
        return "Miau miau"

# Uso
perro = Perro("Rex", "Golden Retriever")
gato = Gato("Whiskers")
print(perro.hacer_sonido())
# Output: ¡Guau! ¡Guau!
print(gato.hacer_sonido())
# Output: Miau miau

print(isinstance(perro, Perro))   # Output: True
print(isinstance(perro, Animal))  # Output: True
print(issubclass(Perro, Animal))  # Output: True

from typing import Union

class Punto2D:
    """
    Representa un punto en el plano cartesiano 2D.
    """
    
    def __init__(self, x=0, y=0) -> None:
        """Constructor: crea punto con coordenadas x, y"""
        self.x = float(x)
        self.y = float(y)
    
    def __repr__(self) -> str:
        """Representación oficial para debug/reconstrucción"""
        return f'Punto2D({self.x}, {self.y})'
    
    def __str__(self) -> str:
        """Representación legible para usuario final"""
        return f'({self.x}, {self.y})'
    
    def __eq__(self, other) -> bool:
        """Comparación de igualdad"""
        if not isinstance(other, Punto2D):
            return NotImplemented
        return self.x == other.x and self.y == other.y
    
    def __lt__(self, other) -> bool:
        """Menor que: orden lexicográfico (primero x, luego y)"""
        if not isinstance(other, Punto2D):
            return NotImplemented
        return (self.x, self.y) < (other.x, other.y)
    
    def __len__(self) -> int:
        """Número de dimensiones (siempre 2)"""
        return 2
    
    def __bool__(self) -> bool:
        """Verdadero si no es el origen (0,0)"""
        return self.x != 0 or self.y != 0
    
    def __add__(self, other: "Point2D") -> "Point2D":
        """Suma vectorial: p1 + p2"""
        if isinstance(other, Punto2D):
            return Punto2D(self.x + other.x, self.y + other.y)
        return NotImplemented
    
    def __sub__(self, other: "Point2D") -> "Point2D":
        """Resta vectorial: p1 - p2"""
        if isinstance(other, Punto2D):
            return Punto2D(self.x - other.x, self.y - other.y)
        return NotImplemented
    
    def __mul__(self, escalar: Union[int, float]) -> "Point2D":
        """Multiplicación por escalar"""
        if isinstance(escalar, (int, float)):
            return Punto2D(self.x * escalar, self.y * escalar)
        return NotImplemented
    
    def __getitem__(self, indice):
        """Acceso por índice: p[0] = x, p[1] = y"""
        if indice == 0:
            return self.x
        elif indice == 1:
            return self.y
        raise IndexError("Índice fuera de rango (0 o 1)")
    
    def distancia_origen(self):
        """Distancia al origen (0,0)"""
        return (self.x ** 2 + self.y ** 2) ** 0.5

import numpy as np

# Array 1D (vector)
array_1d = np.array([1, 2, 3, 4, 5])
# Array 2D (matriz)
array_2d = np.array([[1, 2, 3], 
                     [4, 5, 6]])
# Array 3D
array_3d = np.array([[[1, 2], [3, 4]], 
                     [[5, 6], [7, 8]]])
# Array de ceros
zeros = np.zeros((3, 4))  # 3 filas, 4 columnas
# Array de unos
ones = np.ones((2, 3))
# Array con un valor específico
full = np.full((2, 2), 7)  # Matriz 2x2 llena de 7s
# Array identidad (matriz diagonal con 1s)
identity = np.eye(3)

array_3d.shape             # Dimensiones
array_3d.dtype             # Tipo de dato
array_3d.size              # Total de elementos

# Indexación y slicing
array_1d[0]                # Primer elemento
array_1d[-1]               # Ultimo elemento
array_1d[1:4]              # Elementos 1 a 3
array_1d[::2]              # Cada 2 elementos
array_2d[0, 1]             # Fila 0, columna 1

array_2d.reshape(3, 2)     # Redimensionar
array_2d.T                 # Transpuesta

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

a + b       # Suma
a - b       # Resta
a * b       # Multiplicación
b / a       # División
a ** 2      # Potencia
np.sqrt(a)  # Raíz cuadrada

array = np.array([10, 20, 30, 40, 50, 60])

mask = array > 30       # elementos que cumplen la condición)
resultado = array[mask] # Aplicar la máscara para obtener elementos
array[array > 30]       # [40 50 60]
array[(array > 20) & (array < 50)] # Múltiples condiciones

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

concat = np.concatenate([a, b]) # Concatenar (juntar end-to-end)
concat  # [1 2 3 4 5 6]

# Stack (apilar verticalmente)
m1 = np.array([[1, 2], [3, 4]])
m2 = np.array([[5, 6], [7, 8]])

vstacked = np.vstack([m1, m2])  # Apilar filas
hstacked = np.hstack([m1, m2])  # Apilar columnas

import numpy as np

data = np.array([10, 20, 30, 40, 50])

np.mean(data)   # Media (promedio)
np.median(data) # Mediana
np.std(data)    # Desviación estándar
np.var(data)    # Varianza
np.min(data)    # Mínimo y máximo
np.max(data)
np.sum(data)    # Suma y producto
np.prod(data)
np.percentile(data, 25) # Percentil

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

producto = np.dot(a, b)  # O: a @ b
transpuesta = a.T        # Transpuesta
det = np.linalg.det(a)   # Determinante

inversa = np.linalg.inv(a) # Matriz inversa

# Numeros pseudo aleatorios
# Establecer semilla
np.random.seed(42)
# Uniformes [0, 1)
random_uniform = np.random.rand(5)
# Normales estandar(distribución Gaussiana)
random_normal = np.random.randn(5)
# Enteros aleatorios en rango [0, 10)
random_int = np.random.randint(0, 10, 5)
# Array aleatorio 3x3
random_matrix = np.random.rand(3, 3)

import pandas as pd

serie1 = pd.Series([10, 20, 30, 40])
serie2 = pd.Series([10, 20, 30, 40], 
                   index=['A', 'B', 'C', 'D'])

serie2['B']  # 20 - Acceso por etiqueta
serie2['A']  # 10
# Crear serie desde diccionario
datos = {'España': 47, 'Francia': 67, 'Alemania': 83, 'Italia': 59}
serie_paises = pd.Series(datos)

# Atributos de pd.Serie
serie_paises.size
serie_paises.index
serie_paises.dtype
serie_paises.values

# Dataframe
# Desde diccionario donde cada clave es una columna
datos = {
    'Nombre': ['Alice', 'Bob', 'Carlos', 'Diana'],
    'Edad': [25, 30, 28, 35],
    'Salario': [50000, 60000, 55000, 70000],
    'Departamento': ['Ventas', 'IT', 'Finanzas', 'IT']
}

# Desde lista de datos
datos = [
    ['Alice', 25, 50000],
    ['Bob', 30, 60000],
    ['Carlos', 28, 55000]
]

df = pd.DataFrame(datos, 
                  columns=['Nombre', 'Edad', 'Salario'])
df.shape
df.columns      # Nombre de columnas
df.index        # RangeIndex(start=0, stop=3, step=1)
df.dtypes
df.info()       # Tipo de dato, valores no-nulos
df.head()       # Por defecto, primeras 5 filas
df.head(2)      # Primeras 2 filas
df.tail()       # Últimas 5 filas

df = pd.DataFrame({
    'Nombre': ['Alice', 'Bob', 'Carlos'],
    'Edad': [25, 30, 28],
    'Salario': [50000, 60000, 55000]
})

df.Nombre # Columnas
df['Edad']
df[['Nombre', 'Salario']] # Múltiples columnas

df.loc[0] # Filas
df.loc[0:2]

df.loc[0, 'Nombre'] # Elemento

df.iloc[0] # Por posición (.iloc[])
df.iloc[0:2]
df.iloc[-2:]

# Filtros
df[df['Edad'] > 28]
df[(df['Edad'] > 27) & (df['Salario'] > 55000)]
df[df['Nombre'].isin(['Alice', 'Bob'])]
df[df['Nombre'].str.contains('li')]

# Crear nuevas columnas
df['Fecha Nacimiento'] = 2026 - df['Edad']
df['País'] = 'España'

# Eliminar una columna
df = df.drop('País', axis=1)
df = df.rename(columns={'Edad': 'Años', 'Salario': 'Sueldo'})
df.sort_values(by='Edad')
df.sort_values(by=['Edad', 'Salario'])
df.sort_index()

df = pd.DataFrame({
    'Nombre': ['Alice', 'Bob', np.nan, 'Diana'],
    'Edad': [25, np.nan, 28, 35],
    'Salario': [50000, 60000, 55000, np.nan]
})

# Detectar valores faltantes
print(df.isna())        # Matriz booleana
print(df.isnull())      # Alias para isna()

# Contar valores faltantes
print(df.isna().sum())  # Por columna
# Output:
# Nombre      1
# Edad        1
# Salario     1

# Eliminar filas con valores faltantes
df_limpio = df.dropna()
print(df_limpio)

# Rellenar valores faltantes
df_relleno = df.fillna(0)           # Rellenar con 0
df_relleno = df.fillna(df.mean())   # Rellenar con la media

# Rellenar hacia adelante (forward fill)
df_ffill = df.fillna(method='ffill')

# Rellenar hacia atrás (backward fill)
df_bfill = df.fillna(method='bfill')

df = pd.DataFrame({
    'Edad': [25, 30, 28, 35, 32],
    'Salario': [50000, 60000, 55000, 70000, 62000]
})

# Estadísticas para una columna
print(df['Edad'].mean())       # Media: 30.0
print(df['Edad'].median())     # Mediana: 30
print(df['Edad'].std())        # Desviación estándar
print(df['Edad'].var())        # Varianza
print(df['Edad'].min())        # Mínimo: 25
print(df['Edad'].max())        # Máximo: 35

# Resumen estadístico completo
print(df.describe())

# Contar valores únicos
print(df['Edad'].nunique())    # Número de valores únicos

# Obtener valores únicos
print(df['Edad'].unique())     # [25 30 28 35 32]

# Contar ocurrencias
print(df['Edad'].value_counts())

df = pd.DataFrame({
    'Departamento': ['Ventas', 'IT', 'Finanzas', 'Ventas', 'IT', 'Finanzas'],
    'Empleado': ['Alice', 'Bob', 'Carlos', 'Diana', 'Eve', 'Frank'],
    'Salario': [50000, 60000, 55000, 52000, 65000, 58000]
})

# Agrupar por departamento
grupo = df.groupby('Departamento')

# Calcular la media salarial por departamento
print(grupo['Salario'].mean())

print(grupo['Salario'].agg(['mean', 'min', 'max', 'count']))

print(grupo[['Salario']].describe())

print(grupo.size())

df1 = pd.DataFrame({
    'Nombre': ['Alice', 'Bob'],
    'Edad': [25, 30]
})

df2 = pd.DataFrame({
    'Nombre': ['Carlos', 'Diana'],
    'Edad': [28, 35]
})

# Concatenar verticalmente (apilar filas)
df_concat = pd.concat([df1, df2], ignore_index=True)

# Concatenar horizontalmente (apilar columnas)
df3 = pd.DataFrame({
    'Salario': [50000, 60000, 55000, 70000]
})

df_concat_h = pd.concat([df_concat, df3], axis=1)

# Tabla de empleados
empleados = pd.DataFrame({
    'ID': [1, 2, 3],
    'Nombre': ['Alice', 'Bob', 'Carlos'],
    'Departamento': ['Ventas', 'IT', 'Finanzas']
})

# Tabla de salarios
salarios = pd.DataFrame({
    'ID': [1, 2, 3],
    'Salario': [50000, 60000, 55000]
})

# Merge interno (INNER JOIN)
df_merged = pd.merge(empleados, salarios, on='ID')
print(df_merged)

# Merge izquierdo (LEFT JOIN)
df_left = pd.merge(empleados, salarios, on='ID', how='left')

# Merge derecho (RIGHT JOIN)
df_right = pd.merge(empleados, salarios, on='ID', how='right')

# Merge externo (OUTER JOIN)
df_outer = pd.merge(empleados, salarios, on='ID', how='outer')

import pandas as pd

# Leer un CSV
df = pd.read_csv('datos.csv')

# Guardar a CSV
df.to_csv('datos_procesados.csv', index=False)

# Parámetros útiles
df = pd.read_csv('datos.csv', 
                  sep=';',           # Separador (por defecto ',')
                  encoding='utf-8',  # Codificación
                  nrows=1000)        # Leer solo primeras 1000 filas

# Leer Excel
df = pd.read_excel('datos.xlsx', sheet_name=0)

# Guardar a Excel
df.to_excel('datos.xlsx', index=False)

# Escribir múltiples hojas
with pd.ExcelWriter('datos.xlsx') as writer:
    df1.to_excel(writer, sheet_name='Hoja1', index=False)
    df2.to_excel(writer, sheet_name='Hoja2', index=False)

# Leer JSON
df = pd.read_json('datos.json')

# Guardar a JSON
df.to_json('datos.json', orient='records')

df = pd.DataFrame({
    'Nombre': ['Alice', 'Bob', 'Carlos'],
    'Salario': [50000, 60000, 55000]
})

# Función personalizada
def categorizar_salario(salario):
    if salario < 52000:
        return 'Bajo'
    elif salario < 58000:
        return 'Medio'
    else:
        return 'Alto'

# Aplicar a una columna
df['Categoria'] = df['Salario'].apply(categorizar_salario)

# Usar lambda (funciones anónimas)
df['Salario_Ajustado'] = df['Salario'].apply(lambda x: x * 1.1)  # Aumentar 10%

# Aplicar a toda la fila
df['Nombre_Largo'] = df.apply(lambda row: row['Nombre'] + ' (' + str(row['Salario']) + ')', axis=1)

df = pd.DataFrame({
    'Mes': ['Enero', 'Enero', 'Febrero', 'Febrero'],
    'Región': ['Norte', 'Sur', 'Norte', 'Sur'],
    'Ventas': [1000, 1500, 1200, 1800]
})

# Tabla dinámica
pivot = df.pivot_table(values='Ventas', 
                       index='Mes',
                       columns='Región',
                       aggfunc='sum')

import QuantLib as ql

today = ql.Date(15, 6, 2020)  # Día, Mes, Año
# Establecer como fecha de evaluación global
ql.Settings.instance().evaluationDate = today
print(ql.Settings.instance().evaluationDate)  # June 15th, 2020

# Sumar días
future_date = today + 30  # 30 días después

# Sumar períodos
six_months = today + ql.Period(6, ql.Months)
six_months = today + ql.Period("6M")

# Diferencia entre fechas
days_diff = (six_months - today)

# Calendario: festivos de Estados Unidos
calendar = ql.UnitedStates(ql.UnitedStates.NYSE)

# Contador de días: Actual/360 (mercados monetarios)
dayCounter = ql.Actual360()

# Contador de días: Actual/365 (bonos, derivados)
dayCounter_365 = ql.Actual365Fixed()

# Contador de días: 30/360 (mercados corporativos)
dayCounter_30_360 = ql.Thirty360()

# Contador de días: 30/360 (mercados corporativos)
dayCounter_bus_252 = ql.Business252(calendar)

# Calcular fracción de año
start_date = ql.Date(1, 1, 2020)
end_date = ql.Date(30, 6, 2020)
(end_date - start_date) / 360
year_fraction = dayCounter.yearFraction(start_date, end_date)

calendar.businessDaysBetween(start_date, end_date) / 252
dayCounter_bus_252.yearFraction(start_date, end_date)

import QuantLib as ql
import pandas as pd

start_date = ql.Date(28, 2, 2021)
end_date   = ql.Date(31, 3, 2025)
tenor      = ql.Period("6M")

# Parámetros obligatorios
schedule = ql.MakeSchedule(
    effectiveDate    = start_date,
    terminationDate  = end_date,
    tenor            = tenor)

# Parámetros opcionales
calendar_schedule = ql.MakeSchedule(
    effectiveDate   = start_date,
    terminationDate = end_date,
    tenor           = tenor, 
    calendar        = ql.TARGET())

pd.DataFrame({"sin_calendario": list(schedule),
              "con_calendario": list(calendar_schedule)})

# business day convention
# [ql.Following, ql.ModifiedFollowing, ql.Preceding, ql.ModifiedPreceding]
bus_con_schedule = ql.MakeSchedule(
    effectiveDate   = start_date,
    terminationDate = end_date,
    tenor           = tenor, 
    calendar        = ql.TARGET(),
    convention      = ql.ModifiedFollowing)

pd.DataFrame({"sin_calendario": list(schedule),
              "con_calendario": list(calendar_schedule)},
              "con_bus_conven": list(calendar_schedule))

calendar   = ql.TARGET()
convention = ql.ModifiedFollowing

schedule_backward = ql.MakeSchedule(
    effectiveDate   = start_date,
    terminationDate = end_date,
    tenor           = tenor,
    calendar        = calendar,
    convention      = convention,
    rule            = ql.DateGeneration.Backward)

schedule_forward = ql.MakeSchedule(
    effectiveDate   = start_date,
    terminationDate = end_date,
    tenor           = tenor,
    calendar        = calendar,
    convention      = convention,
    rule            = ql.DateGeneration.Forward)

schedule_eom = ql.MakeSchedule(
    effectiveDate   = start_date,
    terminationDate = end_date,
    tenor           = ql.Period("1M"),
    calendar        = calendar,
    convention      = convention,
    endOfMonth      = True)

schedule_first_long = ql.MakeSchedule(
    effectiveDate   = start_date,
    terminationDate = end_date,
    tenor           = tenor,
    calendar        = calendar,
    convention      = convention,
    rule            = ql.DateGeneration.Backward,
    firstDate       = ql.Date(15, 3, 2021)

import QuantLib as ql

today = ql.Date(15, 6, 2020)
ql.Settings.instance().evaluationDate = today

# Parámetros
settlement_days = 2
calendar = ql.UnitedStates(ql.UnitedStates.NYSE)
rate = 0.05
day_counter = ql.Actual360()

# Crear curva plana
flat_forward = ql.FlatForward(settlement_days, calendar,
                              rate, day_counter)

flat_forward.referenceDate()
flat_forward.discount(today + ql.Period(1, ql.Years))

# Definir puntos de la curva
dates = [ql.Date(15, 6, 2020), 
         ql.Date(15, 12, 2020), 
         ql.Date(15, 6, 2021), 
         ql.Date(15, 6, 2022)]

yields = [0.01, 0.015, 0.02, 0.025]  # Tasas en cada fecha

day_counter = ql.Actual360()

# Crear curva con interpolación lineal
curve = ql.LogLinearZeroCurve(dates, yields, day_counter)

# Handle para usar la curva
curve_handle = ql.YieldTermStructureHandle(curve)

# Obtener tasa forward a una fecha
target_date = ql.Date(15, 9, 2020)
forward_rate = curve_handle.forwardRate(target_date, target_date,
                                        day_counter, ql.Simple)
forward_rate.rate()

import QuantLib as ql

# --- PASO 1: Configurar el entorno ---
today = ql.Date(15, 2, 2025)
ql.Settings.instance().evaluationDate = today

# --- PASO 2: Definir el Contrato ---
# 2.1 Crear el calendario de pagos (Schedule)
schedule = ql.MakeSchedule(effectiveDate=ql.Date(15, 2, 2024),
    terminationDate=ql.Date(15, 2, 2031), tenor=ql.Period(ql.Annual),
    calendar=ql.TARGET(), convention=ql.Following,
    terminationDateConvention=ql.Following, rule=ql.DateGeneration.Backward,
    endOfMonth=False)

# 2.2 Crear el Bono
coupons = [0.03]  # 3% cupón anual
day_count = ql.ActualActual(ql.ActualActual.ISMA)

fixed_rate_bond = ql.FixedRateBond(2,
                                   100,
                                   schedule,
                                   coupons,
                                   day_count)

# --- PASO 3: Definir datos de mercado (La Curva) ---
rate = 0.04
curve_day_count = ql.Actual360()
curve_handle = ql.YieldTermStructureHandle(ql.FlatForward(today, rate, curve_day_count))

# --- PASO 4: Pricing Engine ---
bond_engine = ql.DiscountingBondEngine(curve_handle)

# Definir engine en el bono
fixed_rate_bond.setPricingEngine(bond_engine)

# --- RESULTADOS ---
print(f"NPV (Valor Presente): {fixed_rate_bond.NPV():.4f}")
print(f"Clean Price: {fixed_rate_bond.cleanPrice():.4f}")
print(f"Dirty Price:  {fixed_rate_bond.dirtyPrice():.4f}")
print(f"Accrued Amount (Cupón corrido): {fixed_rate_bond.accruedAmount():.4f}")

# Cálculo de la TIR dado un precio de mercado
market_price = 95.0
yield_rate = fixed_rate_bond.bondYield(
    market_price,
    day_count,
    ql.Compounded,
    ql.Annual)

print(f"Yield (TIR) para precio {market_price}: {yield_rate:.2%}")

import QuantLib as ql

# --- PASO 1: Fecha de valoración ---
today = ql.Date(15, 2, 2026)
ql.Settings.instance().evaluationDate = today
calendar = ql.TARGET()

# --- PASO 2: Curva e Índices ---
rate = 0.03
curve_day_count = ql.Actual365Fixed()

curve_handle = ql.YieldTermStructureHandle(
    ql.FlatForward(today, rate, curve_day_count)
)

# 2.2 El Índice (Euribor 6M)
euribor6m = ql.Euribor6M(curve_handle)

# --- PASO 3: El Contrato (Swap) ---
start_date = ql.Date(17, 2, 2026)  # Spot (T+2)
maturity   = ql.Date(17, 2, 2031)  # 5 años
nominal    = 10_000_000.0          # 10 Millones

# 3.1 Calendario Pata Fija (Anual)
fixed_schedule = ql.MakeSchedule(
    effectiveDate=start_date,
    terminationDate=maturity,
    tenor=ql.Period(ql.Annual),
    calendar=calendar,
    convention=ql.ModifiedFollowing,
    terminationDateConvention=ql.ModifiedFollowing,
    rule=ql.DateGeneration.Forward,
    endOfMonth=False)

# 3.2 Calendario Pata Flotante (Semestral, igual que el Euribor 6M)
float_schedule = ql.MakeSchedule(
    effectiveDate=start_date,
    terminationDate=maturity,
    tenor=ql.Period(ql.Semiannual),
    calendar=calendar,
    convention=ql.ModifiedFollowing,
    terminationDateConvention=ql.ModifiedFollowing,
    rule=ql.DateGeneration.Forward,
    endOfMonth=False
)

# --- PASO 5: Construir el Swap ---
fixed_rate = 0.03  # Pagamos fijo al 3%
spread = 0.0       # Spread sobre Euribor

ir_swap = ql.VanillaSwap(
    ql.VanillaSwap.Payer,  # Nosotros PAGAMOS fijo, RECIBIMOS flotante
    nominal,
    fixed_schedule,
    fixed_rate,
    ql.Thirty360(ql.Thirty360.BondBasis), # DayCount Fijo
    float_schedule,
    euribor6m,
    spread,
    ql.Actual360()                        # DayCount Flotante
)

# --- PASO 5: Pricing Engine ---
engine = ql.DiscountingSwapEngine(curve_handle)
ir_swap.setPricingEngine(engine)

# --- RESULTADOS ---
print(f"NPV (Valor Presente Neto): {ir_swap.NPV():,.2f}")
print(f"Fair Rate (Tasa de mercado): {ir_swap.fairRate():.4%}")
print(f"Fair Spread: {ir_swap.fairSpread():.4%}")

# Análisis de las patas por separado (opcional)
print(f"NPV Pata Fija (lo que pago): {ir_swap.fixedLegNPV():,.2f}")
print(f"NPV Pata Flotante (lo que recibo): {ir_swap.floatingLegNPV():,.2f}")

import QuantLib as ql
import numpy as np

# 1. Configuración de parámetros
S0 = 100.0      # Precio inicial del activo
K = 100.0       # Precio de ejercicio (Strike)
r = 0.05        # Tasa libre de riesgo
sigma = 0.2     # Volatilidad
T = 1.0         # Tiempo hasta vencimiento (años)
div_yield = 0.0 # Rentabilidad por dividendos (asumimos 0)

calculation_date = ql.Date.todaysDate()
maturity_date = calculation_date + ql.Period(int(T*365), ql.Days)

ql.Settings.instance().evaluationDate = calculation_date

# 2. Construcción del Proceso Estocástico (Black-Scholes-Merton)
spot_handle = ql.QuoteHandle(ql.SimpleQuote(S0))
rate_handle = ql.YieldTermStructureHandle(ql.FlatForward(calculation_date, r, ql.Actual365Fixed()))
div_handle = ql.YieldTermStructureHandle(ql.FlatForward(calculation_date, div_yield, ql.Actual365Fixed()))
vol_handle = ql.BlackVolTermStructureHandle(ql.BlackConstantVol(calculation_date, ql.TARGET(), sigma, ql.Actual365Fixed()))

bsm_process = ql.BlackScholesMertonProcess(spot_handle, div_handle, rate_handle, vol_handle)

# 3. Definición de la Opción
payoff = ql.PlainVanillaPayoff(ql.Option.Call, K)
exercise = ql.EuropeanExercise(maturity_date)
european_option = ql.EuropeanOption(payoff, exercise)

# 4. CÁLCULO ANALÍTICO (Fórmula Black-Scholes)
european_option.setPricingEngine(ql.AnalyticEuropeanEngine(bsm_process))
price_analytic = european_option.NPV()

print(f"Precio Black-Scholes: {price_analytic:.6f}")

import QuantLib as ql
import numpy as np

# 1. Configuración de parámetros
S0 = 100.0      # Precio inicial del activo
K = 100.0       # Precio de ejercicio (Strike)
r = 0.05        # Tasa libre de riesgo
sigma = 0.2     # Volatilidad
T = 1.0         # Tiempo hasta vencimiento (años)
div_yield = 0.0 # Rentabilidad por dividendos (asumimos 0)

calculation_date = ql.Date.todaysDate()
maturity_date = calculation_date + ql.Period(int(T*365), ql.Days)

ql.Settings.instance().evaluationDate = calculation_date

# 2. Construcción del Proceso Estocástico (Black-Scholes-Merton)
spot_handle = ql.QuoteHandle(ql.SimpleQuote(S0))
rate_handle = ql.YieldTermStructureHandle(ql.FlatForward(calculation_date, r, ql.Actual365Fixed()))
div_handle = ql.YieldTermStructureHandle(ql.FlatForward(calculation_date, div_yield, ql.Actual365Fixed()))
vol_handle = ql.BlackVolTermStructureHandle(ql.BlackConstantVol(calculation_date, ql.TARGET(), sigma, ql.Actual365Fixed()))

bsm_process = ql.BlackScholesMertonProcess(spot_handle, div_handle, rate_handle, vol_handle)

# 3. Definición de la Opción
payoff = ql.PlainVanillaPayoff(ql.Option.Call, K)
exercise = ql.EuropeanExercise(maturity_date)
european_option = ql.EuropeanOption(payoff, exercise)

# 4. CÁLCULO NUMÉRICO (Monte Carlo)
steps = 1
N = 100000 # Número de simulaciones

mc_engine = ql.MCEuropeanEngine(bsm_process, "PseudoRandom", timeSteps=steps, requiredSamples=N)
european_option.setPricingEngine(mc_engine)
price_mc = european_option.NPV()

print(f"Precio Monte Carlo: {price_mc:.6f}")